﻿#include <iostream>
#include <mutex>

std::recursive_mutex rmtx; // 创建一个递归 mutex 对象
int shared_resource = 0; // 共享资源

// 递归函数
void recursive_increment(int count)
{
	if (count <= 0) return;
	std::lock_guard<std::recursive_mutex> lock(rmtx); // 上锁，确保线程安全
	++shared_resource;
	std::cout << "Incremented shared_resource to " << shared_resource << " (count = " << count << ")" << std::endl;
	// 递归调用
	recursive_increment(count - 1);
}


//提供基本的互斥量，确保在同一时刻只有一个线程可以访问共享资源。
std::mutex mtx;
void thread_function()
{
	std::lock_guard<std::mutex> lock(mtx);
}

//允许同一线程多次获得锁，而不会造成死锁，这对递归函数特别有用。
std::recursive_mutex rmtx2;
void recursive_function(int count)
{
	if (count <= 0) return;
	std::lock_guard<std::recursive_mutex> lock(rmtx2);
	// 递归调用
	recursive_function(count - 1);
}





//提供定时的互斥量，可以在尝试获得锁时设置超时时间。
std::timed_mutex tm;
void try_lock_for_example()
{
	if (tm.try_lock_for(std::chrono::seconds(1)))
	{
		// 成功获得锁
		tm.unlock();
	}
	else
	{
		// 锁获取失败
	}
}



//继承自 std::recursive_timed_mutex，允许同一线程多次获得锁，同时支持定时功能。
std::recursive_timed_mutex rtm3;
void recursive_timed_function(int count)
{
	if (count <= 0) return;
	if (rtm3.try_lock_for(std::chrono::seconds(1)))
	{
		// 成功获得锁
		recursive_timed_function(count - 1);
		rtm3.unlock();
	}
	else
	{
		// 锁获取失败
	}
}





//一种自动管理 std::lock_guard 锁的封装器，使用 RAII 风格，确保在作用域结束时自动释放锁。
std::mutex mtx4;
void function()
{
	std::lock_guard<std::mutex> lock(mtx4);
	// 访问共享资源
}





//提供比 std::unique_lock 更灵活的锁管理，可以手动释放和重新获得锁，还支持定时锁定
std::mutex mtx5;
void function() {
	std::unique_lock<std::mutex> lock(mtx5);
	// 访问共享资源

	// 可以手动释放锁
	lock.unlock();

	// 可以重新获得锁
	lock.lock();

	// 可以进行定时锁定
	if (lock.try_lock_for(std::chrono::seconds(1))) {
		// 成功获得锁
	}
}




std::mutex mtx6;
std::unique_lock<std::mutex> lock(mtx6, std::adopt_lock);


std::mutex mtx7, mtx8;
std::unique_lock<std::mutex> lock1(mtx7, std::try_to_lock);
std::unique_lock<std::mutex> lock2(mtx8, std::try_to_lock);

//if (mtx7 && mtx8)
//{
//	// 成功获得两个锁
//}






int main()
{
	std::thread t1(recursive_increment, 3); // 线程 t1 执行 recursive_increment(3)
	std::thread t2(recursive_increment, 3); // 线程 t2 执行 recursive_increment(3)
	t1.join(); // 等待线程 t1 完成
	t2.join(); // 等待线程 t2 完成
	std::cout << "Final value of shared_resource: " << shared_resource << std::endl;




}